﻿using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Data.SqlClient;
using System.Web;
using System.Web.Services;
using System.Web.Services.Protocols;
using System.Xml.Linq;
using System.Data.OracleClient;
using System.Web.Configuration;
using MySql.Data.MySqlClient;
using Microsoft.AnalysisServices.AdomdClient;
using System.Timers;
using System.IO;

public class Manager
{
	
		private string stringConexion;

        public Manager(string sc)
        {
            stringConexion = sc;
        }
        
        public DataSet GetGraficosParaActualizar()
        {
            SqlDataAdapter da = new SqlDataAdapter("sp_GetGraficosActualizables", stringConexion);
            DataSet ds = new DataSet();
            try
            {

                da.Fill(ds);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return ds;
        }
     
        public void ActualizarDatosGraf(DataRow datos_grafico) {
            try
            {
                //Creo una conexion a la base de datos y la abro
                SqlConnection conexion = new SqlConnection(stringConexion);
                conexion.Open();

                Grafico g = GetGraficoCalculando(datos_grafico);
                ActualizarCabeceraGraf(datos_grafico.ItemArray[0].ToString(),datos_grafico.ItemArray[1].ToString(), g);
                ActualizarDetalleGraf(datos_grafico.ItemArray[0].ToString(), datos_grafico.ItemArray[1].ToString(), g);

                //Creo un objeto SqlCommand en la conexion que acabo de crear para llamar al SP
               

                //Cierro la conexion
                conexion.Close();
            }
            catch (Exception ex)
            {
                //Propago la excepcion para poder mostrarla en pantalla
                throw ex;
            }
        }

        public Grafico[] GetHistoriales(string idGrupo, string[] indicadores){
            ArrayList historiales = new ArrayList();

            foreach (String i in indicadores){

                Grafico g = GetHistorial(idGrupo, i);
                historiales.Add(g);
            }


            Grafico[] hs = new Grafico[historiales.Count];

            for (int i = 0; i < historiales.Count; i++)
            {
                hs[i] = (Grafico)historiales[i];
            }

            return hs;
        }

        public Grafico GetHistorial(string idGrupo,string nombre_indicador) {
            Grafico g = new Grafico();
            DataSet d = GetDatosHistorial(idGrupo, nombre_indicador);
            ArrayList valores = new ArrayList();
            foreach (DataRow item in d.Tables[0].Rows)
            {
                Valor v = new Valor();
                v.ValorS1 = decimal.Parse(item.ItemArray[0].ToString());
                v.Fecha = DateTime.Parse(item.ItemArray[1].ToString());
                valores.Add(v);
            }
            Valor[] vals = new Valor[valores.Count];
            for (int i = 0; i < valores.Count; i++)
            {
                vals[i] = (Valor)valores[i];
            }
            g.Titulo = "Historial del indicador " + nombre_indicador;
            g.CantSeries = 1;
            g.TituloSerie1 = "Valores";
            g.Tipo = "BAR";
            g.Valores = vals;
            return g;


            
        }

        private DataSet GetDatosHistorial(string idGrupo, string nombre){
            SqlDataAdapter da = new SqlDataAdapter("sp_GetHistorialIndicador", stringConexion);
            da.SelectCommand.CommandType = CommandType.StoredProcedure;

            SqlParameter param = new SqlParameter("@id_grupo", SqlDbType.VarChar);
            param.Value = idGrupo;

            da.SelectCommand.Parameters.Add(param);

            SqlParameter param2 = new SqlParameter("@nombre_indicador", SqlDbType.VarChar);
            param2.Value = nombre;

            da.SelectCommand.Parameters.Add(param2);

            DataSet ds = new DataSet();
            try
            {

                da.Fill(ds);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return ds;
        }

        private void ActualizarCabeceraGraf(string idGrupo, string nombre, Grafico g)
        {
            try
            {
                //Creo una conexion a la base de datos y la abro
                SqlConnection conexion = new SqlConnection(stringConexion);
                conexion.Open();
                SqlCommand cmd = new SqlCommand("sp_ActualizarValoresCabeceraGrafico", conexion);
                cmd.CommandType = CommandType.StoredProcedure;


                //Agrego los parametros necesarios en el llamado del SP
                SqlParameter param = new SqlParameter("@id_grupo", SqlDbType.VarChar); param.Value = idGrupo; cmd.Parameters.Add(param);
                param = new SqlParameter("@nombre", SqlDbType.VarChar); param.Value = nombre; cmd.Parameters.Add(param);
                param = new SqlParameter("@titulo", SqlDbType.VarChar); param.Value = g.Titulo; cmd.Parameters.Add(param);
                param = new SqlParameter("@descripcion", SqlDbType.VarChar); param.Value = g.Descripcion; cmd.Parameters.Add(param);
                param = new SqlParameter("@tipo_grafico", SqlDbType.VarChar); param.Value = g.Tipo; cmd.Parameters.Add(param);
                param = new SqlParameter("@titulo_eje_x", SqlDbType.VarChar); param.Value = g.TituloEjeX; cmd.Parameters.Add(param);
                param = new SqlParameter("@titulo_eje_y", SqlDbType.VarChar); param.Value = g.TituloEjeY; cmd.Parameters.Add(param);
                param = new SqlParameter("@titulo_s1", SqlDbType.VarChar); param.Value = g.TituloSerie1; cmd.Parameters.Add(param);
                param = new SqlParameter("@titulo_s2", SqlDbType.VarChar); param.Value = g.TituloSerie2; cmd.Parameters.Add(param);
                param = new SqlParameter("@id_formato_valor", SqlDbType.VarChar); param.Value = g.FormatoValores; cmd.Parameters.Add(param);
                param = new SqlParameter("@cant_series", SqlDbType.VarChar); param.Value = g.CantSeries; cmd.Parameters.Add(param);



                //Ejecuto el SP
                cmd.ExecuteNonQuery();
                conexion.Close();
            }
            catch (Exception ex)
            {
                StreamWriter sw2 = new StreamWriter("D:/errorGraficos.txt", true);
                sw2.WriteLine("error al guardar en nuevo valor de la cabecera del grafico: " + ex.Message);
                sw2.Close();
            }
        }

        private void ActualizarDetalleGraf(string idGrupo, string nombre, Grafico g)
        {

            BorrarValoresAnterioresGraf(idGrupo, nombre);
            AgregarValoresNuevosGraf(idGrupo, nombre, g);
           
        
        }

        private void BorrarValoresAnterioresGraf(string idGrupo, string nombre)
        {
             try
		{
			//Creo una conexion a la base de datos y la abro
			SqlConnection conexion = new SqlConnection(stringConexion);
			conexion.Open();
            SqlCommand cmd = new SqlCommand("sp_BorrarDetalleAntGrafico", conexion);
			cmd.CommandType = CommandType.StoredProcedure;


            SqlParameter param = new SqlParameter("@id_grupo", SqlDbType.VarChar); param.Value = idGrupo; cmd.Parameters.Add(param);
            param = new SqlParameter("@nombre", SqlDbType.VarChar); param.Value = nombre; cmd.Parameters.Add(param);
            cmd.ExecuteNonQuery();
            conexion.Close();
        }
             catch (Exception ex)
             {
                 StreamWriter sw2 = new StreamWriter("D:/errorGraficos.txt", true);
                 sw2.WriteLine("error al borrar el detalle anterior del grafico: " + ex.Message);
                 sw2.Close();
             }
        }

        private void AgregarValoresNuevosGraf(string idGrupo, string nombre, Grafico g)
        { try
		{
            SqlConnection conexion = new SqlConnection(stringConexion);
			conexion.Open();
            foreach (Valor v in g.Valores)
            {
                 SqlCommand cmd = new SqlCommand("sp_AgregarDetalleGrafico", conexion);
			     cmd.CommandType = CommandType.StoredProcedure;
			
                SqlParameter param = new SqlParameter("@id_grupo", SqlDbType.VarChar); param.Value = idGrupo; cmd.Parameters.Add(param);
                param = new SqlParameter("@nombre", SqlDbType.VarChar); param.Value = nombre; cmd.Parameters.Add(param);
                param = new SqlParameter("@titulo_valor", SqlDbType.VarChar); param.Value = v.TituloValor; cmd.Parameters.Add(param);
                param = new SqlParameter("@valor_s1", SqlDbType.VarChar); param.Value = v.ValorS1; cmd.Parameters.Add(param);
                param = new SqlParameter("@valor_s2", SqlDbType.VarChar); param.Value = v.ValorS2; cmd.Parameters.Add(param);
                cmd.ExecuteNonQuery();
            }

            conexion.Close();
        }
        catch (Exception ex)
        {
            StreamWriter sw2 = new StreamWriter("D:/errorGraficos.txt", true);
            sw2.WriteLine("error al guardar en nuevo valor del detalle grafico: " + ex.Message);
            sw2.Close();
        }
  
        }

        public DataSet ObtenerIndicadoresParaActualizar(){
            SqlDataAdapter da = new SqlDataAdapter("sp_GetIndicadoresActualizables", stringConexion);
            DataSet ds = new DataSet();
            try
            {

                da.Fill(ds);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return ds;
        }
        
        public void ActualizarDatosIndicador(DataRow datos){
     

            Indicador i = GetIndicadorCalculando(datos.ItemArray[0].ToString(), datos.ItemArray[1].ToString(), datos);
            StreamWriter sw = new StreamWriter("D:/logIndRecalculado.txt", true);
            sw.WriteLine(i.Nombre +" " + i.ValorActual+ " "+ i.Umbral + "");
            sw.Close();

            try
		{
			//Creo una conexion a la base de datos y la abro
			SqlConnection conexion = new SqlConnection(stringConexion);
			conexion.Open();
            SqlCommand cmd = new SqlCommand("sp_ActualizarValoresIndicador", conexion);
			cmd.CommandType = CommandType.StoredProcedure;

                
                
                SqlParameter param = new SqlParameter("@id_grupo", SqlDbType.VarChar); param.Value = datos.ItemArray[0].ToString(); cmd.Parameters.Add(param);
                param = new SqlParameter("@nombre", SqlDbType.VarChar); param.Value = datos.ItemArray[1].ToString() ; cmd.Parameters.Add(param);
               
                param = new SqlParameter("@descripcion", SqlDbType.VarChar); param.Value = i.Descripcion; cmd.Parameters.Add(param);
                param = new SqlParameter("@valor", SqlDbType.Decimal); param.Value = i.ValorActual; cmd.Parameters.Add(param);
                param = new SqlParameter("@umbral", SqlDbType.Decimal); param.Value = i.Umbral; cmd.Parameters.Add(param);
                param = new SqlParameter("@variacion", SqlDbType.Decimal); param.Value = i.Variacion; cmd.Parameters.Add(param);
                param = new SqlParameter("@id_formato_valor_actual", SqlDbType.VarChar); param.Value = i.FormatoValor; cmd.Parameters.Add(param);
                param = new SqlParameter("@id_formato_valor_variacion", SqlDbType.VarChar); param.Value = i.FormatoVariacion; cmd.Parameters.Add(param);
                param = new SqlParameter("@minimo", SqlDbType.Decimal); param.Value = i.Minimo; cmd.Parameters.Add(param);
                param = new SqlParameter("@maximo", SqlDbType.Decimal); param.Value = i.Maximo; cmd.Parameters.Add(param);
                param = new SqlParameter("@estado_alarma", SqlDbType.Int); param.Value = i.Alarma; cmd.Parameters.Add(param);

                //Ejecuto el SP
                cmd.ExecuteNonQuery();
                
                conexion.Close();
        }
            catch (Exception ex)
            {
                StreamWriter sw2 = new StreamWriter("D:/error.txt", true);
                sw2.WriteLine("error al guardar en nuevo valor del indicador: " + ex.Message);
                sw2.Close();
            }


        }

        public Resultado[] GetValores(string idGrupo)
        {

            DataSet indicadores = GetNombresIndicadores(idGrupo); //tiene solo el nombre de cada indicador
            ArrayList datos_indicadores = new ArrayList();
            string nombre_indicador;

            DataSet datos;



            foreach (DataRow i in indicadores.Tables[0].Rows)
            {
                Resultado r;
                Indicador k;
                Grafico g = null;
                nombre_indicador = (string)i.ItemArray[0];
                datos = GetDatosIndicador(idGrupo, nombre_indicador);
                if (decimal.Parse(datos.Tables[0].Rows[0].ItemArray[11].ToString()) > 0)//si los datos los saca de la BD
                    k = GetIndicadorDeBD(idGrupo, nombre_indicador);

                else
               
                    k = GetIndicadorCalculando(idGrupo, nombre_indicador, datos.Tables[0].Rows[0]);


                if (NecesitaGrafico(idGrupo, nombre_indicador))
                    g = GetGrafico(idGrupo, nombre_indicador);
                r = new Resultado();
                r.Indicador = k;
                GuardarHistorico(idGrupo, k.Nombre, k.ValorActual, k.CantHistoricos);
                r.Grafico = g;

                datos_indicadores.Add(r);
            }

            Resultado[] resultados = new Resultado[datos_indicadores.Count];

            for (int i = 0; i < datos_indicadores.Count; i++)
            {
                resultados[i] = (Resultado)datos_indicadores[i];
            }

            return resultados;
        }

        public Resultado[] GetValoresLista(string idGrupo, string[] indicadores)
        {

           // DataSet kpis = getNombresIndicadores(idGrupo); //tiene solo el nombre de cada kpi
            ArrayList datos_indicadores = new ArrayList();
            string nombre_indicador;

            DataSet datos;



            foreach (string i in indicadores)
            {
                Resultado r;
                Indicador k;
                Grafico g = null;
                nombre_indicador = i;
                datos = GetDatosIndicador(idGrupo, nombre_indicador);
                if (decimal.Parse(datos.Tables[0].Rows[0].ItemArray[11].ToString()) > 0)//si los datos los saca de la BD
                    k = GetIndicadorDeBD(idGrupo, nombre_indicador);

                else
                {
                    k = GetIndicadorCalculando(idGrupo, nombre_indicador, datos.Tables[0].Rows[0]);

                }
                if (NecesitaGrafico(idGrupo, nombre_indicador))
                    g = GetGrafico(idGrupo, nombre_indicador);
                r = new Resultado();
                r.Indicador = k;
                GuardarHistorico(idGrupo, k.Nombre, k.ValorActual, k.CantHistoricos);
                r.Grafico = g;

                datos_indicadores.Add(r);
            }

            Resultado[] resultados = new Resultado[datos_indicadores.Count];

            for (int i = 0; i < datos_indicadores.Count; i++)
            {
                resultados[i] = (Resultado)datos_indicadores[i];
            }

            return resultados;
        }

        public bool Pertenecen(string idGrupo, string[] indicadores){
            DataSet ds = GetNombresIndicadores(idGrupo);
            ArrayList ind_grupo = new ArrayList();
            foreach (DataRow i in ds.Tables[0].Rows)
            {
                ind_grupo.Add((string)i.ItemArray[0]);
            }
            foreach (string ind in indicadores)
            {
                if (!ind_grupo.Contains(ind))
                    return false;
            }
            return true;
        
        }

		private DataSet GetNombresIndicadores(string idGrupo)
		{

			SqlDataAdapter da = new SqlDataAdapter("sp_GetIndicadores", stringConexion);//devuelve solo los nombres

			da.SelectCommand.CommandType = CommandType.StoredProcedure;

			SqlParameter param = new SqlParameter("@id_grupo", SqlDbType.VarChar);
			param.Value = idGrupo;

			da.SelectCommand.Parameters.Add(param);

			DataSet ds = new DataSet();
			try
			{

				da.Fill(ds);
			}
			catch (Exception ex)
			{
				throw ex;
			}

			return ds;
		}

		private DataSet GetDatosIndicador(string idGrupo, string nombre_indicador)
		{
			SqlDataAdapter da = new SqlDataAdapter("sp_GetDatosIndicador", stringConexion);
			da.SelectCommand.CommandType = CommandType.StoredProcedure;

			SqlParameter param = new SqlParameter("@id_grupo", SqlDbType.VarChar);
			param.Value = idGrupo;

			SqlParameter param2 = new SqlParameter("@nombre_indicador", SqlDbType.VarChar);
			param2.Value = nombre_indicador;

			da.SelectCommand.Parameters.Add(param);
			da.SelectCommand.Parameters.Add(param2);

			DataSet datos = new DataSet();
			try
			{
				da.Fill(datos);
			}
			catch (Exception ex)
			{
				throw ex;
			}

			return datos;
		}

        private DataSet GetValorIndicador(string idGrupo, string nombre, DataRow datos)
		{

			DataSet resultado;

            string conexion = datos.ItemArray[4].ToString();
            string query = datos.ItemArray[5].ToString(); 
            string fuente = datos.ItemArray[3].ToString(); ;
			try
			{
				resultado = RealizarQuery(query, fuente, conexion);

			}
			catch (Exception ex)
			{
				throw ex;
			}

			return resultado;

		}

		public DataSet RealizarQuery(string sel, string proveedor, string conexion)//segun el pushbi devuelve fecha,valor,umbral
		{
			DataSet ds = new DataSet();
			if (proveedor == "SQLSERVR")
			{
				SqlDataAdapter da = new SqlDataAdapter(sel, conexion);
				try
				{
					da.Fill(ds);
				}
				catch (Exception ex)
				{
					throw ex;
				}

				return ds;
			}
            else if (proveedor == "MYSQL")
			{
				MySqlDataAdapter a = new MySqlDataAdapter(sel, conexion);
				try
				{
					a.Fill(ds);
				}
				catch (Exception ex)
				{
					throw ex;
				}

				return ds;
			}
            else if (proveedor == "ORCL")
            {
                OracleDataAdapter oda = new OracleDataAdapter(sel, conexion);
                try
                {
                    oda.Fill(ds);
                }
                catch (Exception ex)
                {
                    throw ex;
                }

                return ds;
            }
            else//proveedor==SQLSERVROLAP
            {
                AdomdDataAdapter olapda = new AdomdDataAdapter(sel, conexion);
                try
                {
                    olapda.Fill(ds);
                }
                catch (Exception ex)
                {
                    throw ex;
                }

                return ds;
            }
		}

		public decimal GetVariacion(decimal valor, decimal valor_esperado, string formato_variacion) //el valor esperado se saca de dataset.tables[3] del select del indicador
		{
			if (formato_variacion != "porcentaje")
				return valor - valor_esperado;
			else
                if (valor_esperado!=0)
				    return ((valor - valor_esperado) * 100) / valor_esperado;
                else
                    return (valor - valor_esperado);

		}

		public int GetAlarma(decimal valor,decimal valor_esperado, decimal maximo, decimal minimo, string max_min)//el maximo y minimo son porcentajes, son los umbrales de la variacion
		{
			if (max_min == "MAX")
            {
                if (valor_esperado != 0)
                {
                    if ((((valor - valor_esperado) * 100) / valor_esperado) < minimo)
                        return -1;
                    else if ((((valor - valor_esperado) * 100) / valor_esperado) > maximo)
                        return 1;
                    else
                        return 0;//esta entre el minimo y el maximo
                }
                else {
                    if ((valor - valor_esperado) < minimo)
                        return -1;
                    else if ((valor - valor_esperado)  > maximo)
                        return 1;
                    else
                        return 0;//esta entre el minimo y el maximo
                }
			}
			else
			{
                if (valor_esperado != 0)
                {
                    if ((((valor - valor_esperado) * 100) / valor_esperado) > maximo)
                        return -1;
                    else if ((((valor - valor_esperado) * 100) / valor_esperado) < minimo)
                        return 1;
                    else
                        return 0;//esta entre el minimo y el maximo
                }
                else {
                    if ((valor - valor_esperado) > maximo)
                        return -1;
                    else if ((valor - valor_esperado) < minimo)
                        return 1;
                    else
                        return 0;//esta entre el minimo y el maximo
                }
			}
		}

        private Indicador GetIndicadorCalculando(string idGrupo, string nombre_indicador, DataRow datos)
        {
            string formato_variacion;
            decimal valor;
            decimal valor_esperado;
            Indicador ind = new Indicador();
            DataSet res_consulta = GetValorIndicador(idGrupo, nombre_indicador, datos);
            valor = decimal.Parse(res_consulta.Tables[0].Rows[0].ItemArray[0].ToString()); //Supuestamente 0=valor,1=umbral
            valor_esperado = decimal.Parse(res_consulta.Tables[0].Rows[0].ItemArray[1].ToString());
            formato_variacion = datos.ItemArray[10].ToString();
            if(datos.ItemArray[2]!=null)
             ind.Descripcion = datos.ItemArray[2].ToString();
            ind.Umbral = valor_esperado;
            ind.Nombre = nombre_indicador;
            ind.ValorActual = valor;
            ind.FormatoVariacion = formato_variacion;
            ind.FormatoValor = datos.ItemArray[9].ToString();
            ind.Alarma = GetAlarma(valor,valor_esperado, decimal.Parse(datos.ItemArray[7].ToString()), decimal.Parse(datos.ItemArray[6].ToString()), datos.ItemArray[8].ToString());
            ind.Variacion = GetVariacion(valor, valor_esperado, formato_variacion);
            ind.Maximo = decimal.Parse(datos.ItemArray[7].ToString());
            ind.Minimo = decimal.Parse(datos.ItemArray[6].ToString());
            ind.CantHistoricos = int.Parse(datos.ItemArray[14].ToString());
            if (datos.ItemArray[15] != null)
                ind.NombreResp = datos.ItemArray[15].ToString();
            if (datos.ItemArray[16] != null)
                ind.ApellidoResp = datos.ItemArray[16].ToString();
            if (datos.ItemArray[17] != null)
                ind.EmailResp = datos.ItemArray[17].ToString();
            if (datos.ItemArray[18] != null)
                ind.TelResp = datos.ItemArray[18].ToString();

            //guardarHistorico(idGrupo, nombre_indicador, valor, ind.CantHistoricos);
            return ind;
        }

        private Indicador GetIndicadorDeBD(string idGrupo, string nombre_indicador) {
        DataSet valoresIndicador = GetValoresIndicadorDeBD(idGrupo, nombre_indicador);
        Indicador i = new Indicador();
        i.Nombre=nombre_indicador;
        if (valoresIndicador.Tables[0].Rows[0].ItemArray[2]!=null)
         i.Descripcion=valoresIndicador.Tables[0].Rows[0].ItemArray[2].ToString();
        i.ValorActual=decimal.Parse(valoresIndicador.Tables[0].Rows[0].ItemArray[3].ToString());
        i.Umbral=decimal.Parse(valoresIndicador.Tables[0].Rows[0].ItemArray[4].ToString());
        i.Variacion=decimal.Parse(valoresIndicador.Tables[0].Rows[0].ItemArray[5].ToString());
        i.Minimo = decimal.Parse(valoresIndicador.Tables[0].Rows[0].ItemArray[6].ToString());
        i.Maximo = decimal.Parse(valoresIndicador.Tables[0].Rows[0].ItemArray[7].ToString());
        i.FormatoValor = valoresIndicador.Tables[0].Rows[0].ItemArray[8].ToString();
        i.FormatoVariacion = valoresIndicador.Tables[0].Rows[0].ItemArray[9].ToString();
        i.Alarma = int.Parse(valoresIndicador.Tables[0].Rows[0].ItemArray[10].ToString());
        i.CantHistoricos = int.Parse(valoresIndicador.Tables[0].Rows[0].ItemArray[11].ToString());
        if (valoresIndicador.Tables[0].Rows[0].ItemArray[12] != null)
            i.NombreResp = valoresIndicador.Tables[0].Rows[0].ItemArray[12].ToString();
        if (valoresIndicador.Tables[0].Rows[0].ItemArray[13] != null)
            i.ApellidoResp = valoresIndicador.Tables[0].Rows[0].ItemArray[13].ToString();
        if (valoresIndicador.Tables[0].Rows[0].ItemArray[14] != null)
            i.EmailResp = valoresIndicador.Tables[0].Rows[0].ItemArray[14].ToString();
        if (valoresIndicador.Tables[0].Rows[0].ItemArray[15] != null)
            i.TelResp = valoresIndicador.Tables[0].Rows[0].ItemArray[15].ToString();



        //guardarHistorico(idGrupo, nombre_indicador, i.ValorActual,  i.CantHistoricos);

        return i;

        }
    
        private void  GuardarHistorico(string idGrupo, string nombre_indicador, decimal valor, int maxima_cant){
             try
		     {
			    //Creo una conexion a la base de datos y la abro
			    SqlConnection conexion = new SqlConnection(stringConexion);
			    conexion.Open();
                SqlCommand cmd = new SqlCommand("sp_GuardarHistorico", conexion);
			    cmd.CommandType = CommandType.StoredProcedure;

                
                
                SqlParameter param = new SqlParameter("@id_grupo", SqlDbType.VarChar); param.Value = idGrupo; cmd.Parameters.Add(param);
                param = new SqlParameter("@nombre", SqlDbType.VarChar); param.Value = nombre_indicador ; cmd.Parameters.Add(param);
                param = new SqlParameter("@valor", SqlDbType.Decimal); param.Value = valor; cmd.Parameters.Add(param);
                param = new SqlParameter("@maxima_cant", SqlDbType.Int); param.Value = maxima_cant; cmd.Parameters.Add(param);
                
                 
                
                //Ejecuto el SP
                cmd.ExecuteNonQuery();
                
                conexion.Close();
        }
            catch (Exception ex)
            {
                StreamWriter sw2 = new StreamWriter("D:/error.txt", true);
                sw2.WriteLine("error al guardar el historico del indicador: " + ex.Message);
                sw2.Close();
            }


    }

        private DataSet GetValoresIndicadorDeBD(string idGrupo, string nombre_indicador) {
        
        SqlDataAdapter da = new SqlDataAdapter("sp_GetValoresIndicador", stringConexion);
        da.SelectCommand.CommandType = CommandType.StoredProcedure;

        SqlParameter param = new SqlParameter("@id_Grupo", SqlDbType.VarChar);
        param.Value = idGrupo;

        SqlParameter param2 = new SqlParameter("@nombre_indicador", SqlDbType.VarChar);
        param2.Value = nombre_indicador;

        da.SelectCommand.Parameters.Add(param);
        da.SelectCommand.Parameters.Add(param2);
        DataSet datos = new DataSet();
        try
        {
            da.Fill(datos);
        }
        catch (Exception ex)
        {
            throw ex;
        }
        return datos;
    }

        private bool NecesitaGrafico(string idGrupo,string nombre_indicador){
        DataSet datos_grafico = GetDemandaGrafico(idGrupo, nombre_indicador);
        if (datos_grafico.Tables[0].Rows.Count > 0)//si tiene un grafico asociado
            if (int.Parse(datos_grafico.Tables[0].Rows[0].ItemArray[0].ToString())==0)//si se tiene q enviar junto al indicador
                return true;
    return false;
    }
   
        private DataSet GetDemandaGrafico(string idGrupo, string nombre_indicador)
    {
        SqlDataAdapter da = new SqlDataAdapter("sp_GetDemandaGrafico", stringConexion);

        da.SelectCommand.CommandType = CommandType.StoredProcedure;

        SqlParameter param = new SqlParameter("@id_grupo", SqlDbType.VarChar);
        param.Value = idGrupo;

        SqlParameter param2 = new SqlParameter("@nombre_indicador", SqlDbType.VarChar);
        param2.Value = nombre_indicador;

        da.SelectCommand.Parameters.Add(param);
        da.SelectCommand.Parameters.Add(param2);

        DataSet ds = new DataSet();
        try
        {

            da.Fill(ds);
        }
        catch (Exception ex)
        {
            throw ex;
        }

        return ds;
    }

        public Grafico GetGrafico(string idGrupo,string nombre_indicador){
        Grafico g = null;
        DataSet datos_grafico = GetDatosGrafico(idGrupo, nombre_indicador);
        if (datos_grafico.Tables[0].Rows.Count > 0)//si tiene un grafico asociado
            if(decimal.Parse(datos_grafico.Tables[0].Rows[0].ItemArray[15].ToString())> 0)//si queiere los valores de la bd
                g = GetGraficoDeBD(idGrupo, datos_grafico.Tables[0].Rows[0].ItemArray[1].ToString());
            else
                g= GetGraficoCalculando(datos_grafico.Tables[0].Rows[0]);
       return g;  
    }

        private Grafico GetGraficoCalculando(DataRow datos_grafico)
    {
        Grafico g = new Grafico();
        g.Titulo = datos_grafico.ItemArray[2].ToString();
        g.Descripcion = datos_grafico.ItemArray[3].ToString();
        g.Tipo = datos_grafico.ItemArray[7].ToString();
        g.FormatoValores = datos_grafico.ItemArray[8].ToString();
        g.TituloEjeX = datos_grafico.ItemArray[9].ToString();
        g.TituloEjeY = datos_grafico.ItemArray[10].ToString();
        g.TituloSerie1 = datos_grafico.ItemArray[11].ToString();
        g.TituloSerie2 = datos_grafico.ItemArray[12].ToString();
        g.CantSeries = int.Parse(datos_grafico.ItemArray[18].ToString());
       
        Valor[] valores = GetValoresGrafico(datos_grafico.ItemArray[4].ToString(),//fuente datos
                                                datos_grafico.ItemArray[5].ToString(),//string conexion
                                                datos_grafico.ItemArray[6].ToString(),//query
                                                datos_grafico.ItemArray[7].ToString(),
                                                g.CantSeries);//tipo de grafico
        g.Valores = valores;
        return g;
    
    }

        private Grafico GetGraficoDeBD(string idGrupo,string nombre){
            DataSet valoresCabeceraGrafico = GetValoresCabeceraGraficoDeBD(idGrupo, nombre);
        
        Grafico g=new Grafico();
        g.Titulo=valoresCabeceraGrafico.Tables[0].Rows[0].ItemArray[2].ToString();
        g.Descripcion=valoresCabeceraGrafico.Tables[0].Rows[0].ItemArray[3].ToString();
        g.Tipo=valoresCabeceraGrafico.Tables[0].Rows[0].ItemArray[4].ToString();
        g.TituloEjeX=valoresCabeceraGrafico.Tables[0].Rows[0].ItemArray[5].ToString();
        g.TituloEjeY=valoresCabeceraGrafico.Tables[0].Rows[0].ItemArray[6].ToString();
        g.TituloSerie1=valoresCabeceraGrafico.Tables[0].Rows[0].ItemArray[7].ToString();
        g.TituloSerie2=valoresCabeceraGrafico.Tables[0].Rows[0].ItemArray[8].ToString();
        g.FormatoValores=valoresCabeceraGrafico.Tables[0].Rows[0].ItemArray[9].ToString();
        g.CantSeries = int.Parse(valoresCabeceraGrafico.Tables[0].Rows[0].ItemArray[10].ToString());
        Valor[] valores = GetValoresGraficoDeBD(idGrupo, nombre, g.CantSeries);
        g.Valores = valores;
        return g;
        
    }
   
        private Valor[] GetValoresGraficoDeBD(string idGrupo, string nombre, decimal cant_series) {
            DataSet valoresDetalleGrafico = GetValoresDetalleGraficoDeBD(idGrupo, nombre);
            Valor[] valores = new Valor[valoresDetalleGrafico.Tables[0].Rows.Count];
            ArrayList aux = new ArrayList();
            if(cant_series==2)
                 foreach (DataRow d in valoresDetalleGrafico.Tables[0].Rows)
                 {
                    Valor v = new Valor();
                    v.TituloValor = d.ItemArray[0].ToString();
                    v.ValorS1 = decimal.Parse(d.ItemArray[1].ToString());
                    v.ValorS2 = decimal.Parse(d.ItemArray[2].ToString());
                    aux.Add(v);
                 }
            else
                foreach (DataRow d in valoresDetalleGrafico.Tables[0].Rows)
                {
                    Valor v = new Valor();
                    v.TituloValor = d.ItemArray[0].ToString();
                    v.ValorS1 = decimal.Parse(d.ItemArray[1].ToString());
                    aux.Add(v);
                }

       for (int i = 0; i < aux.Count; i++)
       {
           valores[i] = (Valor)aux[i];
       }
       return valores;
    }

        private DataSet GetValoresCabeceraGraficoDeBD(string idGrupo, string nombre)
        {
        SqlDataAdapter da = new SqlDataAdapter("sp_GetCabeceraGrafico", stringConexion);

        da.SelectCommand.CommandType = CommandType.StoredProcedure;

        SqlParameter param = new SqlParameter("@id_grupo", SqlDbType.VarChar);
        param.Value = idGrupo;

        SqlParameter param2 = new SqlParameter("@nombre", SqlDbType.VarChar);
        param2.Value = nombre;

        da.SelectCommand.Parameters.Add(param);
        da.SelectCommand.Parameters.Add(param2);

        DataSet ds = new DataSet();
        try
        {

            da.Fill(ds);
        }
        catch (Exception ex)
        {
            throw ex;
        }

        return ds;
    }

        private DataSet GetValoresDetalleGraficoDeBD(string idGrupo, string nombre)
    {
        SqlDataAdapter da = new SqlDataAdapter("sp_GetDetalleGrafico", stringConexion);

        da.SelectCommand.CommandType = CommandType.StoredProcedure;

        SqlParameter param = new SqlParameter("@id_grupo", SqlDbType.VarChar);
        param.Value = idGrupo;
         

        SqlParameter param2 = new SqlParameter("@nombre", SqlDbType.VarChar);
        param2.Value = nombre;

        da.SelectCommand.Parameters.Add(param);
        da.SelectCommand.Parameters.Add(param2);

        DataSet ds = new DataSet();
        try
        {

            da.Fill(ds);
        }
        catch (Exception ex)
        {
            throw ex;
        }

        return ds;
    }

        private Valor[] GetValoresGrafico(string fuente, string conexion, string query, string tipo, decimal cant_series)
        {
        Valor[] valores;
        DataSet resultado;
         try
        {
            resultado = RealizarQuery(query, fuente, conexion);

        }
        catch (Exception ex)
        {
            throw ex;
        }

         valores = LlenarValores(resultado, tipo, resultado.Tables[0].Rows.Count, cant_series);
         return valores;
    }

        private Valor[] LlenarValores(DataSet resultado, string tipo, int cantValores, decimal cant_series){
        Valor[] valores = new Valor[cantValores];
        ArrayList l = new ArrayList();
        if (tipo == "TOR") 
            foreach (DataRow fila in resultado.Tables[0].Rows)
            {
                Valor v = new Valor();
                v.TituloValor = fila.ItemArray[0].ToString();
                v.ValorS1 = decimal.Parse(fila.ItemArray[1].ToString());
                l.Add(v);
             }
        else
            if(cant_series==2)
                 foreach (DataRow fila in resultado.Tables[0].Rows)
                {
                     Valor v = new Valor();
                     v.TituloValor = fila.ItemArray[0].ToString();
                     v.ValorS1 = decimal.Parse(fila.ItemArray[1].ToString());
                     v.ValorS2 = decimal.Parse(fila.ItemArray[2].ToString());
                     l.Add(v);
                }
            else
                foreach (DataRow fila in resultado.Tables[0].Rows)
                {
                    Valor v = new Valor();
                    v.TituloValor = fila.ItemArray[0].ToString();
                    v.ValorS1 = decimal.Parse(fila.ItemArray[1].ToString());
                    l.Add(v);
                }
      

        for (int i = 0; i < l.Count; i++)
            valores[i] = (Valor)l[i];
            
        return valores;       
        
    }
    
        private DataSet GetDatosGrafico(string idGrupo, string nombre_indicador)
    {
        SqlDataAdapter da = new SqlDataAdapter("sp_GetGrafico", stringConexion);

        da.SelectCommand.CommandType = CommandType.StoredProcedure;

        SqlParameter param = new SqlParameter("@id_grupo", SqlDbType.VarChar);
        param.Value = idGrupo;

        SqlParameter param2 = new SqlParameter("@nombre_indicador", SqlDbType.VarChar);
        param2.Value = nombre_indicador;

        da.SelectCommand.Parameters.Add(param);
        da.SelectCommand.Parameters.Add(param2);

        DataSet ds = new DataSet();
        try
        {

            da.Fill(ds);
        }
        catch (Exception ex)
        {
            throw ex;
        }

        return ds;
    }

        public bool Pertenece(string idGrupo, string usuario)
        {
            DataSet ds = GetInfoUsuarioGrupo(idGrupo, usuario);
            if (ds.Tables[0].Rows.Count > 0)
                return true;
            return false;
        }

        private DataSet GetInfoUsuarioGrupo(string idGrupo, string usuario)
        {
            SqlDataAdapter da = new SqlDataAdapter("sp_GetGrupoUsuario", stringConexion);//devuelve solo los nombres

            da.SelectCommand.CommandType = CommandType.StoredProcedure;

            SqlParameter param = new SqlParameter("@id_grupo", SqlDbType.VarChar);
            param.Value = idGrupo;
            SqlParameter param2 = new SqlParameter("@usuario", SqlDbType.VarChar);
            param2.Value = usuario;






            da.SelectCommand.Parameters.Add(param);
            da.SelectCommand.Parameters.Add(param2);

            DataSet ds = new DataSet();
            try
            {

                da.Fill(ds);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return ds;
        }

        public bool AutenticarUsuario(string usuario, string contrasenia)
        {
            SqlDataAdapter da = new SqlDataAdapter("sp_GetDatosLogin", stringConexion);
            da.SelectCommand.CommandType = CommandType.StoredProcedure;

            SqlParameter param = new SqlParameter("@usuario", SqlDbType.VarChar);
            param.Value = usuario;

            SqlParameter param2 = new SqlParameter("@contrasenia", SqlDbType.VarChar);
            param2.Value = contrasenia;

            da.SelectCommand.Parameters.Add(param);
            da.SelectCommand.Parameters.Add(param2);
            DataSet datos = new DataSet();
            try
            {
                da.Fill(datos);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            if (datos.Tables[0].Rows.Count == 0)
                return false;
            else
                return true;
        }

        
}
